const api = require('../../../utils/api');

// 确保全局唯一页面实例，避免内存泄漏
let pageInstance = null;

Page({
  // 页面数据
  data: {
    shareId: '',        // 分享ID
    shareDetail: null,  // 分享详情
    loading: true,      // 加载状态
    status: true,       // 页面状态
    errorMsg: '',       // 错误信息
    userInfo: null,     // 当前用户信息
    commentText: '',    // 评论输入内容
    userId: '',         // 分享用户ID
    sysInfo: wx.getSystemInfoSync() // 系统信息，用于适配不同设备
  },

  // 页面初始化
  onLoad(options) {
    // 存储页面实例引用
    pageInstance = this;

    // 获取分享ID和用户ID
    const { id, userId } = options || {};
    this.setData({
      shareId: id || '',
      userId: userId || ''
    });
    
    console.log('跳转到分享详情页，参数:', { shareId: this.data.shareId, userId: this.data.userId });
    
    // 加载分享详情
    this.loadShareDetail();
    // 获取当前用户信息
    this.getUserInfo();
  },

  // 获取分享详情
  loadShareDetail() {
    // 防止连续加载
    if (this.loadingLock) return;
    this.loadingLock = true;

    if (!this.data.shareId) {
      this.setData({
        status: false,
        errorMsg: '无效的分享ID',
        loading: false
      });
      this.loadingLock = false;
      return;
    }

    this.setData({ loading: true, errorMsg: '' });

    try {
      // 调用API获取分享详情
      const promise = api.community.getShareDetail(this.data.shareId);
        
      promise.then(res => {
        console.log('分享详情API返回:', res);
        
        // 优先处理API返回的数据，不使用模拟数据
        if (res && (res.code === 0 || res.success) && res.data) {
          // 处理返回的数据，确保符合模板需求
          const shareData = this.formatShareData(res.data);
          
          this.setData({
            shareDetail: shareData,
            status: true,
            loading: false
          });
        } else if (res && res.data) {
          // 如果有数据但状态码不是标准格式，也尝试使用
          console.log('API返回非标准格式，但尝试使用数据');
          const shareData = this.formatShareData(res.data);
          
          this.setData({
            shareDetail: shareData,
            status: true,
            loading: false
          });
        } else {
          // 显示错误信息，不使用模拟数据
          console.log('API调用失败，显示错误信息');
          this.setData({
            status: false,
            errorMsg: '获取分享详情失败',
            loading: false
          });
        }
      }).catch(err => {
        console.error('获取分享详情失败:', err);
        // 显示错误信息，不使用模拟数据
        this.setData({
          status: false,
          errorMsg: '网络请求失败，请检查网络连接',
          loading: false
        });
      }).finally(() => {
        this.loadingLock = false;
      });
    } catch (e) {
      console.error('loadShareDetail异常:', e);
      // 显示错误信息，不使用模拟数据
      this.setData({
        status: false,
        errorMsg: '系统异常，请稍后重试',
        loading: false
      });
      this.loadingLock = false;
    }
  },
  
  // 格式化分享数据 - 优化以与communityMain保持一致
  formatShareData(data) {
    console.log('原始API数据:', data);
    
    // 获取本地缓存的点赞状态和点赞数，与communityMain保持一致
    let isLiked = false;
    let likeCount = Number(data.favoriteCount || data.favorite_count || data.likeCount || 0);
    const itemId = data.id || this.data.shareId;
    
    try {
      const likedPosts = wx.getStorageSync('likedPosts') || {};
      if (likedPosts[itemId] !== undefined) {
        isLiked = likedPosts[itemId].isLiked;
        // 如果缓存中有点赞数，则使用缓存的点赞数
        if (likedPosts[itemId].likeCount !== undefined) {
          likeCount = Number(likedPosts[itemId].likeCount);
        }
        console.log(`从本地缓存应用点赞状态和点赞数: 帖子ID=${itemId}, isLiked=${isLiked}, likeCount=${likeCount}`);
      }
    } catch (error) {
      console.error('读取本地点赞缓存失败:', error);
    }
    
    // 基础数据处理 - 根据API文档字段格式，优先使用API返回的数据
    const postUserId = data.createUser || data.userId || this.data.userId || '';
    console.log('处理分享数据，用户ID:', postUserId, '分享ID:', data.id || this.data.shareId);
    
    const formatted = {
      id: data.id || this.data.shareId,
      userId: postUserId, // 使用API返回的用户ID或页面参数中的userId
      username: data.username || data.nickname || '用户' + postUserId || '用户', // 优先使用API返回的用户名
      // 头像处理 - 优先使用API返回的头像
      userAvatar: data.avatarUrl || data.avatar || '/static/pic/icon-test_2.png',
      title: data.title || '', // 直接使用title字段
      content: data.description || data.content || data.desc || '', // 适配多种可能的内容字段
      createTime: data.createTime ? this.formatTime(data.createTime) : '刚刚',
      isLiked: isLiked, // 从缓存获取初始点赞状态
      likeCount: likeCount, // 从缓存获取点赞数
      viewCount: data.viewCount || 0, // 新增浏览次数
      status: data.status || 1,
      likedUsers: [], // 初始化为空数组
      commentCount: Number(data.commentCount || data.comment_count || 0), // 评论数
      comments: [],
      images: []
    };
    
    // 处理图片数组
    if (data.imageUrls && Array.isArray(data.imageUrls)) {
      formatted.images = data.imageUrls;
    }
    
    // 获取用户信息以完善用户名和头像
    this.getUserInfoForShare(data.createUser, formatted);
    
    return formatted;
  },
  
  // 获取分享用户的详细信息
  getUserInfoForShare(userId, shareData) {
    if (!userId) return;
    
    try {
      api.my.getUserInfo(userId).then(userRes => {
        console.log('获取用户信息结果:', userRes);
        
        if (userRes && userRes.data) {
          // 只在有有效用户信息时更新，避免覆盖从帖子详情API获取的数据
          const userName = userRes.data.name || userRes.data.nickname;
          const userAvatar = userRes.data.avatar || userRes.data.avatarUrl;
          
          // 只有当用户名或头像有值时才更新
          if (userName || userAvatar) {
            if (userName) shareData.username = userName;
            if (userAvatar) shareData.userAvatar = userAvatar;
            
            console.log('更新用户信息:', { userName, userAvatar });
            
            // 刷新页面数据
            this.setData({
              shareDetail: { ...this.data.shareDetail }
            });
          }
        }
      }).catch(err => {
        console.error('获取分享用户信息失败:', err);
        // 失败时不做处理，继续使用已有的用户信息
      });
    } catch (e) {
      console.error('getUserInfoForShare异常:', e);
    }
  },
  
  // 使用模拟数据 - 符合API文档格式
  useMockData() {
    // 获取当前的shareId和userId
    const shareId = parseInt(this.data.shareId || '1');
    const userId = parseInt(this.data.userId || '2');
    
    // 创建符合API文档格式的模拟数据，根据shareId和userId动态生成内容
    const titles = [
      `安铺古镇之旅 #${shareId}`,
      `美食探索分享 #${shareId}`,
      `旅行见闻记录 #${shareId}`,
      `文化体验心得 #${shareId}`,
      `风景摄影分享 #${shareId}`
    ];
    
    const contents = [
      `这是用户${userId}分享的内容，帖子ID: ${shareId}。分享了一些关于安铺古镇的精彩体验和见闻。`,
      `用户${userId}的美食探索之旅，帖子ID: ${shareId}。推荐了当地特色美食和小吃。`,
      `旅行达人用户${userId}的最新分享，帖子ID: ${shareId}。记录了旅途中的美好瞬间。`,
      `文化爱好者用户${userId}分享，帖子ID: ${shareId}。带您领略安铺的传统文化魅力。`,
      `摄影师用户${userId}作品展示，帖子ID: ${shareId}。用镜头记录美丽风景。`
    ];
    
    const titleIndex = shareId % titles.length;
    const contentIndex = shareId % contents.length;
    
    const mockApiData = {
      id: shareId,
      title: titles[titleIndex],
      description: contents[contentIndex],
      postUrl: null,
      imageUrls: [
        '/static/pic/icon-test_3.png',
        '/static/pic/icon-test_4.png'
      ],
      favoriteCount: shareId * 5, // 根据ID生成不同的点赞数
      viewCount: shareId * 20, // 根据ID生成不同的浏览数
      status: 1,
      createUser: userId,
      createTime: new Date(Date.now() - (shareId % 24) * 60 * 60 * 1000).toISOString(), // 根据ID生成不同的发布时间
      updateTime: new Date(Date.now() - (shareId % 24) * 60 * 60 * 1000).toISOString()
    };
    
    // 使用formatShareData处理模拟数据
    const formattedData = this.formatShareData(mockApiData);
    
    // 手动补充一些UI需要的数据，根据userId动态生成用户名
    formattedData.username = `用户${formattedData.userId || this.data.userId}`; // 使用实际的用户ID
    formattedData.isLiked = false;
    // 简化数据，只保留必要信息
    formattedData.likedUsers = [];
    formattedData.commentCount = 0;
    formattedData.comments = [];
    
    this.setData({
      shareDetail: formattedData,
      status: true,
      loading: false
    });
  },
  
  // 格式化时间
  formatTime(timeStr) {
    try {
      const date = new Date(timeStr);
      const now = new Date();
      const diff = now - date;
      
      const minute = 1000 * 60;
      const hour = minute * 60;
      const day = hour * 24;
      
      if (diff < minute) {
        return '刚刚';
      } else if (diff < hour) {
        return Math.floor(diff / minute) + '分钟前';
      } else if (diff < day) {
        return Math.floor(diff / hour) + '小时前';
      } else if (diff < day * 7) {
        return Math.floor(diff / day) + '天前';
      } else {
        return date.toLocaleDateString();
      }
    } catch (e) {
      return '刚刚';
    }
  },
  
  // 获取用户信息
  getUserInfo() {
    // 从缓存或登录信息中获取用户ID，避免直接使用ID=1
    let userId = wx.getStorageSync('userId') || '';
    
    // 如果没有用户ID，不执行后续操作
    if (!userId) {
      console.log('未找到用户ID，跳过获取用户信息');
      return;
    }
    
    try {
      api.my.getUserInfo(userId).then(res => {
        if (res && res.data) {
          this.setData({
            userInfo: res.data
          });
        }
      }).catch(err => {
        console.error('获取用户信息失败:', err);
      });
    } catch (e) {
      console.error('getUserInfo异常:', e);
    }
  },
  
  // 切换点赞状态 - 与communityMain保持一致的实现
  toggleLike() {
    if (!this.data.shareDetail) return;
    
    const isLiked = !this.data.shareDetail.isLiked;
    const likeCount = isLiked ? 
      this.data.shareDetail.likeCount + 1 : 
      Math.max(0, this.data.shareDetail.likeCount - 1);
    
    this.setData({
      'shareDetail.isLiked': isLiked,
      'shareDetail.likeCount': likeCount
    });
    
    console.log(`分享 ${this.data.shareId} 点赞状态切换为: ${isLiked}，点赞数: ${likeCount}`);
    
    // 调用API保存点赞状态到服务器 - 与communityMain保持一致
    this.saveLikeToServer(this.data.shareId, isLiked);
    
    // 保存点赞状态和点赞数到本地缓存
    this.saveLikeToCache(this.data.shareId, isLiked, likeCount);
  },
  
  // 调用API保存点赞状态到服务器 - 与communityMain完全一致
  async saveLikeToServer(postId, isLiked) {
    try {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.log('未登录，跳过服务器保存');
        return;
      }
      
      console.log(`保存点赞状态到服务器: 帖子ID=${postId}, 点赞=${isLiked}`);
      // 使用与communityMain相同的API调用方式，targetType=7
      await api.like.changeLike(postId, isLiked, 7);
      console.log('点赞状态保存到服务器成功');
    } catch (error) {
      console.error('保存点赞状态到服务器失败:', error);
      // 不影响用户体验，仅记录错误，不恢复原状态
    }
  },
  
  // 保存点赞状态和点赞数到本地缓存 - 与communityMain保持一致
  saveLikeToCache(postId, isLiked, likeCount) {
    try {
      console.log(`保存点赞状态和点赞数到本地缓存: 帖子ID=${postId}, 点赞=${isLiked}, 点赞数=${likeCount}`);
      
      // 获取现有点赞缓存
      let likedPosts = wx.getStorageSync('likedPosts') || {};
      
      // 更新点赞状态和点赞数
      likedPosts[postId] = {
        isLiked: isLiked,
        likeCount: likeCount,
        timestamp: new Date().getTime()
      };
      
      // 保存到本地缓存
      wx.setStorageSync('likedPosts', likedPosts);
      console.log('点赞状态和点赞数保存到本地缓存成功');
    } catch (error) {
      console.error('保存点赞状态和点赞数到本地缓存失败:', error);
    }
  },
  

  
  // 跳转到用户分享页面
  goToUserShare() {
    const userId = this.data.shareDetail?.userId || this.data.userId;
    if (userId) {
      console.log('跳转到用户分享页面，用户ID:', userId);
      wx.navigateTo({
        url: `/pages/community/userShare/userShare?userId=${userId}`
      });
    }
  },
  
  // 分享帖子
  sharePost() {
    wx.showShareMenu({
      withShareTicket: true,
      menus: ['shareAppMessage', 'shareTimeline']
    });
  },
  

  
  // 图片预览
  previewImage(e) {
    try {
      const { index } = e.currentTarget.dataset || {};
      const images = this.data.shareDetail?.images || [];
      
      if (images.length > 0 && index !== undefined && index < images.length) {
        wx.previewImage({
          current: images[index],
          urls: images,
          success: () => {
            console.log('图片预览成功');
          },
          fail: (err) => {
            console.error('图片预览失败:', err);
            wx.showToast({
              title: '预览失败',
              icon: 'none'
            });
          }
        });
      }
    } catch (e) {
      console.error('previewImage异常:', e);
    }
  },
  
  // 下拉刷新
  onPullDownRefresh() {
    this.loadShareDetail();
    // 在数据加载完成后停止下拉刷新动画
  },

  // 页面卸载时清理
  onUnload() {
    // 清理页面实例引用，避免内存泄漏
    pageInstance = null;
    // 清理定时器等资源
    if (this.timeoutId) {
      clearTimeout(this.timeoutId);
    }
  },

  // 页面隐藏时暂停操作
  onHide() {
    // 可以在这里暂停一些不必要的操作
  },

  // 页面显示时恢复操作
  onShow() {
    // 可以在这里恢复一些必要的操作
  }
});
